<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE
    FlexibleInstances
  , MultiParamTypeClasses
  , RoleAnnotations
 #-}</span><span>
</span><span id="line-6"></span><span>
</span><span id="line-7"></span><span class="hs-pragma">{-# OPTIONS_HADDOCK hide #-}</span><span>
</span><span id="line-8"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-9"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-10"></span><span class="hs-comment">-- Module      :  Data.Array.IO.Internal</span><span>
</span><span id="line-11"></span><span class="hs-comment">-- Copyright   :  (c) The University of Glasgow 2001-2012</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- License     :  BSD-style (see the file libraries/base/LICENSE)</span><span>
</span><span id="line-13"></span><span class="hs-comment">--</span><span>
</span><span id="line-14"></span><span class="hs-comment">-- Maintainer  :  libraries@haskell.org</span><span>
</span><span id="line-15"></span><span class="hs-comment">-- Stability   :  experimental</span><span>
</span><span id="line-16"></span><span class="hs-comment">-- Portability :  non-portable (uses Data.Array.Base)</span><span>
</span><span id="line-17"></span><span class="hs-comment">--</span><span>
</span><span id="line-18"></span><span class="hs-comment">-- Mutable boxed and unboxed arrays in the IO monad.</span><span>
</span><span id="line-19"></span><span class="hs-comment">--</span><span>
</span><span id="line-20"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-21"></span><span>
</span><span id="line-22"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">Data.Array.IO.Internals</span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-23"></span><span>    </span><span class="annot"><a href="../../base/src/GHC.IOArray.html#IOArray"><span class="hs-identifier">IOArray</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>         </span><span class="hs-comment">-- instance of: Eq, Typeable</span><span>
</span><span id="line-24"></span><span>    </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier">IOUArray</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">,</span><span>        </span><span class="hs-comment">-- instance of: Eq, Typeable</span><span>
</span><span id="line-25"></span><span>    </span><span class="annot"><a href="Data.Array.IO.Internals.html#castIOUArray"><span class="hs-identifier">castIOUArray</span></a></span><span class="hs-special">,</span><span>        </span><span class="hs-comment">-- :: IOUArray ix a -&gt; IO (IOUArray ix b)</span><span>
</span><span id="line-26"></span><span>    </span><span class="annot"><a href="Data.Array.IO.Internals.html#unsafeThawIOUArray"><span class="hs-identifier">unsafeThawIOUArray</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-27"></span><span>    </span><span class="annot"><a href="Data.Array.IO.Internals.html#unsafeFreezeIOUArray"><span class="hs-identifier">unsafeFreezeIOUArray</span></a></span><span>
</span><span id="line-28"></span><span>  </span><span class="hs-special">)</span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-29"></span><span>
</span><span id="line-30"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Int.html#"><span class="hs-identifier">Data.Int</span></a></span><span>
</span><span id="line-31"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Data.Word.html#"><span class="hs-identifier">Data.Word</span></a></span><span>
</span><span id="line-32"></span><span>
</span><span id="line-33"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Control.Monad.ST.html#"><span class="hs-identifier">Control.Monad.ST</span></a></span><span>         </span><span class="hs-special">(</span><span> </span><span class="annot"><span class="hs-identifier">RealWorld</span></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier">stToIO</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-34"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Foreign.Ptr.html#"><span class="hs-identifier">Foreign.Ptr</span></a></span><span>              </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/GHC.Ptr.html#Ptr"><span class="hs-identifier">Ptr</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="../../base/src/GHC.Ptr.html#FunPtr"><span class="hs-identifier">FunPtr</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-35"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/Foreign.StablePtr.html#"><span class="hs-identifier">Foreign.StablePtr</span></a></span><span>        </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="../../base/src/GHC.Stable.html#StablePtr"><span class="hs-identifier">StablePtr</span></a></span><span> </span><span class="hs-special">)</span><span>
</span><span id="line-36"></span><span>
</span><span id="line-37"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Array.Base.html"><span class="hs-identifier">Data.Array.Base</span></a></span><span>
</span><span id="line-38"></span><span>
</span><span id="line-39"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../base/src/GHC.IOArray.html#"><span class="hs-identifier">GHC.IOArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.IOArray.html#IOArray"><span class="hs-identifier">IOArray</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-40"></span><span>
</span><span id="line-41"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-42"></span><span class="hs-comment">-- Flat unboxed mutable arrays (IO monad)</span><span>
</span><span id="line-43"></span><span>
</span><span id="line-44"></span><span class="hs-comment">-- | Mutable, unboxed, strict arrays in the 'IO' monad.  The type</span><span>
</span><span id="line-45"></span><span class="hs-comment">-- arguments are as follows:</span><span>
</span><span id="line-46"></span><span class="hs-comment">--</span><span>
</span><span id="line-47"></span><span class="hs-comment">--  * @i@: the index type of the array (should be an instance of 'Ix')</span><span>
</span><span id="line-48"></span><span class="hs-comment">--</span><span>
</span><span id="line-49"></span><span class="hs-comment">--  * @e@: the element type of the array.  Only certain element types</span><span>
</span><span id="line-50"></span><span class="hs-comment">--    are supported: see &quot;Data.Array.MArray&quot; for a list of instances.</span><span>
</span><span id="line-51"></span><span class="hs-comment">--</span><span>
</span><span id="line-52"></span><span class="hs-keyword">newtype</span><span> </span><span id="IOUArray"><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span></span><span> </span><span id="local-6989586621679054193"><span class="annot"><a href="#local-6989586621679054193"><span class="hs-identifier hs-type">i</span></a></span></span><span> </span><span id="local-6989586621679054192"><span class="annot"><a href="#local-6989586621679054192"><span class="hs-identifier hs-type">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span id="IOUArray"><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.Base.html#STUArray"><span class="hs-identifier hs-type">STUArray</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">RealWorld</span></span><span> </span><span class="annot"><a href="#local-6989586621679054193"><span class="hs-identifier hs-type">i</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054192"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-53"></span><span class="hs-comment">-- Both parameters have class-based invariants. See also #9220.</span><span>
</span><span id="line-54"></span><span class="hs-keyword">type</span><span> </span><span class="hs-keyword">role</span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><span class="hs-identifier">nominal</span></span><span> </span><span class="annot"><span class="hs-identifier">nominal</span></span><span>
</span><span id="line-55"></span><span>
</span><span id="line-56"></span><span id="local-6989586621679054220"><span id="local-6989586621679054221"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679054011"><span class="annot"><span class="hs-identifier hs-type">Eq</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054221"><span class="hs-identifier hs-type">i</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054220"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-57"></span><span>    </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679054007"><span class="annot"><span class="annottext">STUArray RealWorld i e
</span><a href="#local-6989586621679054007"><span class="hs-identifier hs-var">s1</span></a></span></span><span> </span><span id="local-6989586621679054006"><span class="annot"><span class="annottext">== :: IOUArray i e -&gt; IOUArray i e -&gt; Bool
</span><span class="hs-operator hs-var hs-var hs-var hs-var">==</span></span></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679054005"><span class="annot"><span class="annottext">STUArray RealWorld i e
</span><a href="#local-6989586621679054005"><span class="hs-identifier hs-var">s2</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span>  </span><span class="annot"><span class="annottext">STUArray RealWorld i e
</span><a href="#local-6989586621679054007"><span class="hs-identifier hs-var">s1</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i e -&gt; STUArray RealWorld i e -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><span class="hs-operator hs-var">==</span></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i e
</span><a href="#local-6989586621679054005"><span class="hs-identifier hs-var">s2</span></a></span></span></span><span>
</span><span id="line-58"></span><span>
</span><span id="line-59"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Bool</span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-60"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-61"></span><span>    </span><span id="local-6989586621679053987"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Bool -&gt; IO (i, i)
</span><a href="#local-6989586621679053987"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053986"><span class="annot"><span class="annottext">STUArray RealWorld i Bool
</span><a href="#local-6989586621679053986"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Bool -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Bool
</span><a href="#local-6989586621679053986"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-62"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-63"></span><span>    </span><span id="local-6989586621679053981"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Bool -&gt; IO Int
</span><a href="#local-6989586621679053981"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053980"><span class="annot"><span class="annottext">STUArray RealWorld i Bool
</span><a href="#local-6989586621679053980"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Bool -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Bool
</span><a href="#local-6989586621679053980"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-64"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-65"></span><span>    </span><span id="local-6989586621679053972"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Bool -&gt; IO (IOUArray i Bool)
</span><a href="#local-6989586621679053972"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053971"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053971"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053970"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679053970"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Bool) -&gt; IO (IOUArray i Bool)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Bool) -&gt; IO (IOUArray i Bool))
-&gt; ST RealWorld (IOUArray i Bool) -&gt; IO (IOUArray i Bool)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-66"></span><span>        </span><span id="local-6989586621679053969"><span class="annot"><span class="annottext">STUArray RealWorld i Bool
</span><a href="#local-6989586621679053969"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Bool -&gt; ST RealWorld (STUArray RealWorld i Bool)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053971"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679053970"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Bool -&gt; ST RealWorld (IOUArray i Bool)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Bool -&gt; IOUArray i Bool
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Bool
</span><a href="#local-6989586621679053969"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-67"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-68"></span><span>    </span><span id="local-6989586621679053962"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Bool)
</span><a href="#local-6989586621679053962"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053961"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053961"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Bool) -&gt; IO (IOUArray i Bool)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Bool) -&gt; IO (IOUArray i Bool))
-&gt; ST RealWorld (IOUArray i Bool) -&gt; IO (IOUArray i Bool)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-69"></span><span>        </span><span id="local-6989586621679053960"><span class="annot"><span class="annottext">STUArray RealWorld i Bool
</span><a href="#local-6989586621679053960"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Bool)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053961"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Bool -&gt; ST RealWorld (IOUArray i Bool)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Bool -&gt; IOUArray i Bool
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Bool
</span><a href="#local-6989586621679053960"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-70"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-71"></span><span>    </span><span id="local-6989586621679053955"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Bool)
</span><a href="#local-6989586621679053955"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Bool)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-72"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-73"></span><span>    </span><span id="local-6989586621679053950"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Bool -&gt; Int -&gt; IO Bool
</span><a href="#local-6989586621679053950"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053949"><span class="annot"><span class="annottext">STUArray RealWorld i Bool
</span><a href="#local-6989586621679053949"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053948"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053948"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Bool -&gt; IO Bool
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Bool -&gt; Int -&gt; ST RealWorld Bool
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Bool
</span><a href="#local-6989586621679053949"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053948"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-74"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-75"></span><span>    </span><span id="local-6989586621679053943"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Bool -&gt; Int -&gt; Bool -&gt; IO ()
</span><a href="#local-6989586621679053943"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053942"><span class="annot"><span class="annottext">STUArray RealWorld i Bool
</span><a href="#local-6989586621679053942"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053941"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053941"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053940"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679053940"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Bool -&gt; Int -&gt; Bool -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Bool
</span><a href="#local-6989586621679053942"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053941"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679053940"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-76"></span><span>
</span><span id="line-77"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Char</span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-78"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-79"></span><span>    </span><span id="local-6989586621679053925"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Char -&gt; IO (i, i)
</span><a href="#local-6989586621679053925"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053924"><span class="annot"><span class="annottext">STUArray RealWorld i Char
</span><a href="#local-6989586621679053924"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Char -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Char
</span><a href="#local-6989586621679053924"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-80"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-81"></span><span>    </span><span id="local-6989586621679053920"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Char -&gt; IO Int
</span><a href="#local-6989586621679053920"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053919"><span class="annot"><span class="annottext">STUArray RealWorld i Char
</span><a href="#local-6989586621679053919"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Char -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Char
</span><a href="#local-6989586621679053919"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-82"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-83"></span><span>    </span><span id="local-6989586621679053913"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Char -&gt; IO (IOUArray i Char)
</span><a href="#local-6989586621679053913"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053912"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053912"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053911"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679053911"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Char) -&gt; IO (IOUArray i Char)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Char) -&gt; IO (IOUArray i Char))
-&gt; ST RealWorld (IOUArray i Char) -&gt; IO (IOUArray i Char)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-84"></span><span>        </span><span id="local-6989586621679053910"><span class="annot"><span class="annottext">STUArray RealWorld i Char
</span><a href="#local-6989586621679053910"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Char -&gt; ST RealWorld (STUArray RealWorld i Char)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053912"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679053911"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Char -&gt; ST RealWorld (IOUArray i Char)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Char -&gt; IOUArray i Char
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Char
</span><a href="#local-6989586621679053910"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-85"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-86"></span><span>    </span><span id="local-6989586621679053904"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Char)
</span><a href="#local-6989586621679053904"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053903"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053903"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Char) -&gt; IO (IOUArray i Char)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Char) -&gt; IO (IOUArray i Char))
-&gt; ST RealWorld (IOUArray i Char) -&gt; IO (IOUArray i Char)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-87"></span><span>        </span><span id="local-6989586621679053902"><span class="annot"><span class="annottext">STUArray RealWorld i Char
</span><a href="#local-6989586621679053902"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Char)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053903"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Char -&gt; ST RealWorld (IOUArray i Char)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Char -&gt; IOUArray i Char
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Char
</span><a href="#local-6989586621679053902"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-88"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-89"></span><span>    </span><span id="local-6989586621679053898"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Char)
</span><a href="#local-6989586621679053898"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Char)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-90"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-91"></span><span>    </span><span id="local-6989586621679053894"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Char -&gt; Int -&gt; IO Char
</span><a href="#local-6989586621679053894"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053893"><span class="annot"><span class="annottext">STUArray RealWorld i Char
</span><a href="#local-6989586621679053893"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053892"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053892"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Char -&gt; IO Char
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Char -&gt; Int -&gt; ST RealWorld Char
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Char
</span><a href="#local-6989586621679053893"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053892"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-92"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-93"></span><span>    </span><span id="local-6989586621679053888"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Char -&gt; Int -&gt; Char -&gt; IO ()
</span><a href="#local-6989586621679053888"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053887"><span class="annot"><span class="annottext">STUArray RealWorld i Char
</span><a href="#local-6989586621679053887"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053886"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053886"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053885"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679053885"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Char -&gt; Int -&gt; Char -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Char
</span><a href="#local-6989586621679053887"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053886"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679053885"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-94"></span><span>
</span><span id="line-95"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Int</span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-96"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-97"></span><span>    </span><span id="local-6989586621679053870"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Int -&gt; IO (i, i)
</span><a href="#local-6989586621679053870"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053869"><span class="annot"><span class="annottext">STUArray RealWorld i Int
</span><a href="#local-6989586621679053869"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int
</span><a href="#local-6989586621679053869"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-98"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-99"></span><span>    </span><span id="local-6989586621679053865"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Int -&gt; IO Int
</span><a href="#local-6989586621679053865"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053864"><span class="annot"><span class="annottext">STUArray RealWorld i Int
</span><a href="#local-6989586621679053864"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int
</span><a href="#local-6989586621679053864"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-100"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-101"></span><span>    </span><span id="local-6989586621679053858"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Int -&gt; IO (IOUArray i Int)
</span><a href="#local-6989586621679053858"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053857"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053857"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053856"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053856"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Int) -&gt; IO (IOUArray i Int)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Int) -&gt; IO (IOUArray i Int))
-&gt; ST RealWorld (IOUArray i Int) -&gt; IO (IOUArray i Int)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-102"></span><span>        </span><span id="local-6989586621679053855"><span class="annot"><span class="annottext">STUArray RealWorld i Int
</span><a href="#local-6989586621679053855"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Int -&gt; ST RealWorld (STUArray RealWorld i Int)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053857"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053856"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Int -&gt; ST RealWorld (IOUArray i Int)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int -&gt; IOUArray i Int
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int
</span><a href="#local-6989586621679053855"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-103"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-104"></span><span>    </span><span id="local-6989586621679053849"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Int)
</span><a href="#local-6989586621679053849"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053848"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053848"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Int) -&gt; IO (IOUArray i Int)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Int) -&gt; IO (IOUArray i Int))
-&gt; ST RealWorld (IOUArray i Int) -&gt; IO (IOUArray i Int)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-105"></span><span>        </span><span id="local-6989586621679053847"><span class="annot"><span class="annottext">STUArray RealWorld i Int
</span><a href="#local-6989586621679053847"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Int)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053848"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Int -&gt; ST RealWorld (IOUArray i Int)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int -&gt; IOUArray i Int
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int
</span><a href="#local-6989586621679053847"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-106"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-107"></span><span>    </span><span id="local-6989586621679053843"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Int)
</span><a href="#local-6989586621679053843"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Int)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-108"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-109"></span><span>    </span><span id="local-6989586621679053839"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Int -&gt; Int -&gt; IO Int
</span><a href="#local-6989586621679053839"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053838"><span class="annot"><span class="annottext">STUArray RealWorld i Int
</span><a href="#local-6989586621679053838"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053837"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053837"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int -&gt; Int -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int
</span><a href="#local-6989586621679053838"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053837"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-110"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-111"></span><span>    </span><span id="local-6989586621679053833"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Int -&gt; Int -&gt; Int -&gt; IO ()
</span><a href="#local-6989586621679053833"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053832"><span class="annot"><span class="annottext">STUArray RealWorld i Int
</span><a href="#local-6989586621679053832"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053831"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053831"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053830"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053830"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int -&gt; Int -&gt; Int -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int
</span><a href="#local-6989586621679053832"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053831"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053830"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-112"></span><span>
</span><span id="line-113"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Word</span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-114"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-115"></span><span>    </span><span id="local-6989586621679053815"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Word -&gt; IO (i, i)
</span><a href="#local-6989586621679053815"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053814"><span class="annot"><span class="annottext">STUArray RealWorld i Word
</span><a href="#local-6989586621679053814"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word
</span><a href="#local-6989586621679053814"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-116"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-117"></span><span>    </span><span id="local-6989586621679053810"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Word -&gt; IO Int
</span><a href="#local-6989586621679053810"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053809"><span class="annot"><span class="annottext">STUArray RealWorld i Word
</span><a href="#local-6989586621679053809"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word
</span><a href="#local-6989586621679053809"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-118"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-119"></span><span>    </span><span id="local-6989586621679053803"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Word -&gt; IO (IOUArray i Word)
</span><a href="#local-6989586621679053803"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053802"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053802"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053801"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621679053801"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Word) -&gt; IO (IOUArray i Word)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Word) -&gt; IO (IOUArray i Word))
-&gt; ST RealWorld (IOUArray i Word) -&gt; IO (IOUArray i Word)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-120"></span><span>        </span><span id="local-6989586621679053800"><span class="annot"><span class="annottext">STUArray RealWorld i Word
</span><a href="#local-6989586621679053800"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Word -&gt; ST RealWorld (STUArray RealWorld i Word)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053802"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621679053801"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Word -&gt; ST RealWorld (IOUArray i Word)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word -&gt; IOUArray i Word
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word
</span><a href="#local-6989586621679053800"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-121"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-122"></span><span>    </span><span id="local-6989586621679053794"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Word)
</span><a href="#local-6989586621679053794"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053793"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053793"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Word) -&gt; IO (IOUArray i Word)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Word) -&gt; IO (IOUArray i Word))
-&gt; ST RealWorld (IOUArray i Word) -&gt; IO (IOUArray i Word)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-123"></span><span>        </span><span id="local-6989586621679053792"><span class="annot"><span class="annottext">STUArray RealWorld i Word
</span><a href="#local-6989586621679053792"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Word)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053793"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Word -&gt; ST RealWorld (IOUArray i Word)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word -&gt; IOUArray i Word
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word
</span><a href="#local-6989586621679053792"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-124"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-125"></span><span>    </span><span id="local-6989586621679053788"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Word)
</span><a href="#local-6989586621679053788"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Word)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-126"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-127"></span><span>    </span><span id="local-6989586621679053784"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Word -&gt; Int -&gt; IO Word
</span><a href="#local-6989586621679053784"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053783"><span class="annot"><span class="annottext">STUArray RealWorld i Word
</span><a href="#local-6989586621679053783"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053782"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053782"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Word -&gt; IO Word
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word -&gt; Int -&gt; ST RealWorld Word
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word
</span><a href="#local-6989586621679053783"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053782"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-128"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-129"></span><span>    </span><span id="local-6989586621679053778"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Word -&gt; Int -&gt; Word -&gt; IO ()
</span><a href="#local-6989586621679053778"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053777"><span class="annot"><span class="annottext">STUArray RealWorld i Word
</span><a href="#local-6989586621679053777"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053776"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053776"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053775"><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621679053775"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word -&gt; Int -&gt; Word -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word
</span><a href="#local-6989586621679053777"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053776"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Word
</span><a href="#local-6989586621679053775"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-130"></span><span>
</span><span id="line-131"></span><span id="local-6989586621679054162"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Ptr.html#Ptr"><span class="hs-identifier hs-type">Ptr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054162"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-132"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-133"></span><span>    </span><span id="local-6989586621679053760"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i (Ptr a) -&gt; IO (i, i)
</span><a href="#local-6989586621679053760"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053759"><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a)
</span><a href="#local-6989586621679053759"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a) -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a)
</span><a href="#local-6989586621679053759"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-134"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-135"></span><span>    </span><span id="local-6989586621679053755"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i (Ptr a) -&gt; IO Int
</span><a href="#local-6989586621679053755"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053754"><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a)
</span><a href="#local-6989586621679053754"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a) -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a)
</span><a href="#local-6989586621679053754"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-136"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-137"></span><span>    </span><span id="local-6989586621679053748"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Ptr a -&gt; IO (IOUArray i (Ptr a))
</span><a href="#local-6989586621679053748"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053747"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053747"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053746"><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679053746"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i (Ptr a)) -&gt; IO (IOUArray i (Ptr a))
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i (Ptr a)) -&gt; IO (IOUArray i (Ptr a)))
-&gt; ST RealWorld (IOUArray i (Ptr a)) -&gt; IO (IOUArray i (Ptr a))
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-138"></span><span>        </span><span id="local-6989586621679053745"><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a)
</span><a href="#local-6989586621679053745"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Ptr a -&gt; ST RealWorld (STUArray RealWorld i (Ptr a))
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053747"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679053746"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i (Ptr a) -&gt; ST RealWorld (IOUArray i (Ptr a))
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a) -&gt; IOUArray i (Ptr a)
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a)
</span><a href="#local-6989586621679053745"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-139"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-140"></span><span>    </span><span id="local-6989586621679053739"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i (Ptr a))
</span><a href="#local-6989586621679053739"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053738"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053738"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i (Ptr a)) -&gt; IO (IOUArray i (Ptr a))
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i (Ptr a)) -&gt; IO (IOUArray i (Ptr a)))
-&gt; ST RealWorld (IOUArray i (Ptr a)) -&gt; IO (IOUArray i (Ptr a))
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-141"></span><span>        </span><span id="local-6989586621679053737"><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a)
</span><a href="#local-6989586621679053737"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i (Ptr a))
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053738"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i (Ptr a) -&gt; ST RealWorld (IOUArray i (Ptr a))
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a) -&gt; IOUArray i (Ptr a)
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a)
</span><a href="#local-6989586621679053737"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-142"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-143"></span><span>    </span><span id="local-6989586621679053733"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i (Ptr a))
</span><a href="#local-6989586621679053733"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i (Ptr a))
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-144"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-145"></span><span>    </span><span id="local-6989586621679053729"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i (Ptr a) -&gt; Int -&gt; IO (Ptr a)
</span><a href="#local-6989586621679053729"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053728"><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a)
</span><a href="#local-6989586621679053728"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053727"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053727"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (Ptr a) -&gt; IO (Ptr a)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a) -&gt; Int -&gt; ST RealWorld (Ptr a)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a)
</span><a href="#local-6989586621679053728"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053727"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-146"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-147"></span><span>    </span><span id="local-6989586621679053723"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i (Ptr a) -&gt; Int -&gt; Ptr a -&gt; IO ()
</span><a href="#local-6989586621679053723"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053722"><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a)
</span><a href="#local-6989586621679053722"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053721"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053721"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053720"><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679053720"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a) -&gt; Int -&gt; Ptr a -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (Ptr a)
</span><a href="#local-6989586621679053722"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053721"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Ptr a
</span><a href="#local-6989586621679053720"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-148"></span><span>
</span><span id="line-149"></span><span id="local-6989586621679054151"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Ptr.html#FunPtr"><span class="hs-identifier hs-type">FunPtr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054151"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-150"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-151"></span><span>    </span><span id="local-6989586621679053705"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i (FunPtr a) -&gt; IO (i, i)
</span><a href="#local-6989586621679053705"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053704"><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
</span><a href="#local-6989586621679053704"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a) -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
</span><a href="#local-6989586621679053704"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-152"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-153"></span><span>    </span><span id="local-6989586621679053700"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i (FunPtr a) -&gt; IO Int
</span><a href="#local-6989586621679053700"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053699"><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
</span><a href="#local-6989586621679053699"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a) -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
</span><a href="#local-6989586621679053699"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-154"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-155"></span><span>    </span><span id="local-6989586621679053693"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; FunPtr a -&gt; IO (IOUArray i (FunPtr a))
</span><a href="#local-6989586621679053693"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053692"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053692"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053691"><span class="annot"><span class="annottext">FunPtr a
</span><a href="#local-6989586621679053691"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i (FunPtr a)) -&gt; IO (IOUArray i (FunPtr a))
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i (FunPtr a))
 -&gt; IO (IOUArray i (FunPtr a)))
-&gt; ST RealWorld (IOUArray i (FunPtr a))
-&gt; IO (IOUArray i (FunPtr a))
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-156"></span><span>        </span><span id="local-6989586621679053690"><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
</span><a href="#local-6989586621679053690"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i)
-&gt; FunPtr a -&gt; ST RealWorld (STUArray RealWorld i (FunPtr a))
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053692"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">FunPtr a
</span><a href="#local-6989586621679053691"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i (FunPtr a) -&gt; ST RealWorld (IOUArray i (FunPtr a))
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a) -&gt; IOUArray i (FunPtr a)
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
</span><a href="#local-6989586621679053690"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-157"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-158"></span><span>    </span><span id="local-6989586621679053684"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i (FunPtr a))
</span><a href="#local-6989586621679053684"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053683"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053683"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i (FunPtr a)) -&gt; IO (IOUArray i (FunPtr a))
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i (FunPtr a))
 -&gt; IO (IOUArray i (FunPtr a)))
-&gt; ST RealWorld (IOUArray i (FunPtr a))
-&gt; IO (IOUArray i (FunPtr a))
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-159"></span><span>        </span><span id="local-6989586621679053682"><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
</span><a href="#local-6989586621679053682"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i (FunPtr a))
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053683"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i (FunPtr a) -&gt; ST RealWorld (IOUArray i (FunPtr a))
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a) -&gt; IOUArray i (FunPtr a)
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
</span><a href="#local-6989586621679053682"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-160"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-161"></span><span>    </span><span id="local-6989586621679053678"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i (FunPtr a))
</span><a href="#local-6989586621679053678"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i (FunPtr a))
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-162"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-163"></span><span>    </span><span id="local-6989586621679053674"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i (FunPtr a) -&gt; Int -&gt; IO (FunPtr a)
</span><a href="#local-6989586621679053674"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053673"><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
</span><a href="#local-6989586621679053673"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053672"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053672"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (FunPtr a) -&gt; IO (FunPtr a)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a) -&gt; Int -&gt; ST RealWorld (FunPtr a)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
</span><a href="#local-6989586621679053673"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053672"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-164"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-165"></span><span>    </span><span id="local-6989586621679053668"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i (FunPtr a) -&gt; Int -&gt; FunPtr a -&gt; IO ()
</span><a href="#local-6989586621679053668"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053667"><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
</span><a href="#local-6989586621679053667"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053666"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053666"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053665"><span class="annot"><span class="annottext">FunPtr a
</span><a href="#local-6989586621679053665"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
-&gt; Int -&gt; FunPtr a -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (FunPtr a)
</span><a href="#local-6989586621679053667"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053666"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">FunPtr a
</span><a href="#local-6989586621679053665"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-166"></span><span>
</span><span id="line-167"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Float</span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-168"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-169"></span><span>    </span><span id="local-6989586621679053650"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Float -&gt; IO (i, i)
</span><a href="#local-6989586621679053650"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053649"><span class="annot"><span class="annottext">STUArray RealWorld i Float
</span><a href="#local-6989586621679053649"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Float -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Float
</span><a href="#local-6989586621679053649"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-170"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-171"></span><span>    </span><span id="local-6989586621679053645"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Float -&gt; IO Int
</span><a href="#local-6989586621679053645"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053644"><span class="annot"><span class="annottext">STUArray RealWorld i Float
</span><a href="#local-6989586621679053644"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Float -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Float
</span><a href="#local-6989586621679053644"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-172"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-173"></span><span>    </span><span id="local-6989586621679053638"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Float -&gt; IO (IOUArray i Float)
</span><a href="#local-6989586621679053638"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053637"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053637"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053636"><span class="annot"><span class="annottext">Float
</span><a href="#local-6989586621679053636"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Float) -&gt; IO (IOUArray i Float)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Float) -&gt; IO (IOUArray i Float))
-&gt; ST RealWorld (IOUArray i Float) -&gt; IO (IOUArray i Float)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-174"></span><span>        </span><span id="local-6989586621679053635"><span class="annot"><span class="annottext">STUArray RealWorld i Float
</span><a href="#local-6989586621679053635"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Float -&gt; ST RealWorld (STUArray RealWorld i Float)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053637"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Float
</span><a href="#local-6989586621679053636"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Float -&gt; ST RealWorld (IOUArray i Float)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Float -&gt; IOUArray i Float
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Float
</span><a href="#local-6989586621679053635"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-175"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-176"></span><span>    </span><span id="local-6989586621679053629"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Float)
</span><a href="#local-6989586621679053629"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053628"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053628"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Float) -&gt; IO (IOUArray i Float)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Float) -&gt; IO (IOUArray i Float))
-&gt; ST RealWorld (IOUArray i Float) -&gt; IO (IOUArray i Float)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-177"></span><span>        </span><span id="local-6989586621679053627"><span class="annot"><span class="annottext">STUArray RealWorld i Float
</span><a href="#local-6989586621679053627"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Float)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053628"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Float -&gt; ST RealWorld (IOUArray i Float)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Float -&gt; IOUArray i Float
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Float
</span><a href="#local-6989586621679053627"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-178"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-179"></span><span>    </span><span id="local-6989586621679053623"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Float)
</span><a href="#local-6989586621679053623"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Float)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-180"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-181"></span><span>    </span><span id="local-6989586621679053619"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Float -&gt; Int -&gt; IO Float
</span><a href="#local-6989586621679053619"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053618"><span class="annot"><span class="annottext">STUArray RealWorld i Float
</span><a href="#local-6989586621679053618"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053617"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053617"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Float -&gt; IO Float
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Float -&gt; Int -&gt; ST RealWorld Float
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Float
</span><a href="#local-6989586621679053618"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053617"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-182"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-183"></span><span>    </span><span id="local-6989586621679053613"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Float -&gt; Int -&gt; Float -&gt; IO ()
</span><a href="#local-6989586621679053613"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053612"><span class="annot"><span class="annottext">STUArray RealWorld i Float
</span><a href="#local-6989586621679053612"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053611"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053611"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053610"><span class="annot"><span class="annottext">Float
</span><a href="#local-6989586621679053610"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Float -&gt; Int -&gt; Float -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Float
</span><a href="#local-6989586621679053612"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053611"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Float
</span><a href="#local-6989586621679053610"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-184"></span><span>
</span><span id="line-185"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">Double</span></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-186"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-187"></span><span>    </span><span id="local-6989586621679053595"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Double -&gt; IO (i, i)
</span><a href="#local-6989586621679053595"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053594"><span class="annot"><span class="annottext">STUArray RealWorld i Double
</span><a href="#local-6989586621679053594"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Double -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Double
</span><a href="#local-6989586621679053594"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-188"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-189"></span><span>    </span><span id="local-6989586621679053590"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Double -&gt; IO Int
</span><a href="#local-6989586621679053590"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053589"><span class="annot"><span class="annottext">STUArray RealWorld i Double
</span><a href="#local-6989586621679053589"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Double -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Double
</span><a href="#local-6989586621679053589"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-190"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-191"></span><span>    </span><span id="local-6989586621679053583"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Double -&gt; IO (IOUArray i Double)
</span><a href="#local-6989586621679053583"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053582"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053582"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053581"><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621679053581"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Double) -&gt; IO (IOUArray i Double)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Double) -&gt; IO (IOUArray i Double))
-&gt; ST RealWorld (IOUArray i Double) -&gt; IO (IOUArray i Double)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-192"></span><span>        </span><span id="local-6989586621679053580"><span class="annot"><span class="annottext">STUArray RealWorld i Double
</span><a href="#local-6989586621679053580"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Double -&gt; ST RealWorld (STUArray RealWorld i Double)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053582"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621679053581"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Double -&gt; ST RealWorld (IOUArray i Double)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Double -&gt; IOUArray i Double
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Double
</span><a href="#local-6989586621679053580"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-193"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-194"></span><span>    </span><span id="local-6989586621679053574"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Double)
</span><a href="#local-6989586621679053574"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053573"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053573"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Double) -&gt; IO (IOUArray i Double)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Double) -&gt; IO (IOUArray i Double))
-&gt; ST RealWorld (IOUArray i Double) -&gt; IO (IOUArray i Double)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-195"></span><span>        </span><span id="local-6989586621679053572"><span class="annot"><span class="annottext">STUArray RealWorld i Double
</span><a href="#local-6989586621679053572"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Double)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053573"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Double -&gt; ST RealWorld (IOUArray i Double)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Double -&gt; IOUArray i Double
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Double
</span><a href="#local-6989586621679053572"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-196"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-197"></span><span>    </span><span id="local-6989586621679053568"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Double)
</span><a href="#local-6989586621679053568"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Double)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-198"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-199"></span><span>    </span><span id="local-6989586621679053564"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Double -&gt; Int -&gt; IO Double
</span><a href="#local-6989586621679053564"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053563"><span class="annot"><span class="annottext">STUArray RealWorld i Double
</span><a href="#local-6989586621679053563"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053562"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053562"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Double -&gt; IO Double
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Double -&gt; Int -&gt; ST RealWorld Double
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Double
</span><a href="#local-6989586621679053563"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053562"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-200"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-201"></span><span>    </span><span id="local-6989586621679053558"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Double -&gt; Int -&gt; Double -&gt; IO ()
</span><a href="#local-6989586621679053558"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053557"><span class="annot"><span class="annottext">STUArray RealWorld i Double
</span><a href="#local-6989586621679053557"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053556"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053556"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053555"><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621679053555"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Double -&gt; Int -&gt; Double -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Double
</span><a href="#local-6989586621679053557"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053556"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Double
</span><a href="#local-6989586621679053555"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-202"></span><span>
</span><span id="line-203"></span><span id="local-6989586621679054124"><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../base/src/GHC.Stable.html#StablePtr"><span class="hs-identifier hs-type">StablePtr</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054124"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-204"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-205"></span><span>    </span><span id="local-6989586621679053540"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i (StablePtr a) -&gt; IO (i, i)
</span><a href="#local-6989586621679053540"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053539"><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
</span><a href="#local-6989586621679053539"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a) -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
</span><a href="#local-6989586621679053539"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-206"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-207"></span><span>    </span><span id="local-6989586621679053535"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i (StablePtr a) -&gt; IO Int
</span><a href="#local-6989586621679053535"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053534"><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
</span><a href="#local-6989586621679053534"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a) -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
</span><a href="#local-6989586621679053534"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-208"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-209"></span><span>    </span><span id="local-6989586621679053528"><span class="annot"><span class="annottext">newArray :: forall i.
Ix i =&gt;
(i, i) -&gt; StablePtr a -&gt; IO (IOUArray i (StablePtr a))
</span><a href="#local-6989586621679053528"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053527"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053527"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053526"><span class="annot"><span class="annottext">StablePtr a
</span><a href="#local-6989586621679053526"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i (StablePtr a))
-&gt; IO (IOUArray i (StablePtr a))
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i (StablePtr a))
 -&gt; IO (IOUArray i (StablePtr a)))
-&gt; ST RealWorld (IOUArray i (StablePtr a))
-&gt; IO (IOUArray i (StablePtr a))
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-210"></span><span>        </span><span id="local-6989586621679053525"><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
</span><a href="#local-6989586621679053525"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i)
-&gt; StablePtr a -&gt; ST RealWorld (STUArray RealWorld i (StablePtr a))
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053527"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">StablePtr a
</span><a href="#local-6989586621679053526"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i (StablePtr a) -&gt; ST RealWorld (IOUArray i (StablePtr a))
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a) -&gt; IOUArray i (StablePtr a)
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
</span><a href="#local-6989586621679053525"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-211"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-212"></span><span>    </span><span id="local-6989586621679053519"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i (StablePtr a))
</span><a href="#local-6989586621679053519"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053518"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053518"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i (StablePtr a))
-&gt; IO (IOUArray i (StablePtr a))
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i (StablePtr a))
 -&gt; IO (IOUArray i (StablePtr a)))
-&gt; ST RealWorld (IOUArray i (StablePtr a))
-&gt; IO (IOUArray i (StablePtr a))
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-213"></span><span>        </span><span id="local-6989586621679053517"><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
</span><a href="#local-6989586621679053517"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i (StablePtr a))
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053518"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i (StablePtr a) -&gt; ST RealWorld (IOUArray i (StablePtr a))
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a) -&gt; IOUArray i (StablePtr a)
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
</span><a href="#local-6989586621679053517"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-214"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-215"></span><span>    </span><span id="local-6989586621679053513"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i (StablePtr a))
</span><a href="#local-6989586621679053513"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i (StablePtr a))
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-216"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-217"></span><span>    </span><span id="local-6989586621679053509"><span class="annot"><span class="annottext">unsafeRead :: forall i.
Ix i =&gt;
IOUArray i (StablePtr a) -&gt; Int -&gt; IO (StablePtr a)
</span><a href="#local-6989586621679053509"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053508"><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
</span><a href="#local-6989586621679053508"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053507"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053507"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (StablePtr a) -&gt; IO (StablePtr a)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
-&gt; Int -&gt; ST RealWorld (StablePtr a)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
</span><a href="#local-6989586621679053508"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053507"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-218"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-219"></span><span>    </span><span id="local-6989586621679053503"><span class="annot"><span class="annottext">unsafeWrite :: forall i.
Ix i =&gt;
IOUArray i (StablePtr a) -&gt; Int -&gt; StablePtr a -&gt; IO ()
</span><a href="#local-6989586621679053503"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053502"><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
</span><a href="#local-6989586621679053502"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053501"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053501"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053500"><span class="annot"><span class="annottext">StablePtr a
</span><a href="#local-6989586621679053500"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
-&gt; Int -&gt; StablePtr a -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i (StablePtr a)
</span><a href="#local-6989586621679053502"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053501"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">StablePtr a
</span><a href="#local-6989586621679053500"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-220"></span><span>
</span><span id="line-221"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int8"><span class="hs-identifier hs-type">Int8</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-222"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-223"></span><span>    </span><span id="local-6989586621679053485"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Int8 -&gt; IO (i, i)
</span><a href="#local-6989586621679053485"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053484"><span class="annot"><span class="annottext">STUArray RealWorld i Int8
</span><a href="#local-6989586621679053484"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int8 -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int8
</span><a href="#local-6989586621679053484"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-224"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-225"></span><span>    </span><span id="local-6989586621679053480"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Int8 -&gt; IO Int
</span><a href="#local-6989586621679053480"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053479"><span class="annot"><span class="annottext">STUArray RealWorld i Int8
</span><a href="#local-6989586621679053479"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int8 -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int8
</span><a href="#local-6989586621679053479"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-226"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-227"></span><span>    </span><span id="local-6989586621679053473"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Int8 -&gt; IO (IOUArray i Int8)
</span><a href="#local-6989586621679053473"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053472"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053472"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053471"><span class="annot"><span class="annottext">Int8
</span><a href="#local-6989586621679053471"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Int8) -&gt; IO (IOUArray i Int8)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Int8) -&gt; IO (IOUArray i Int8))
-&gt; ST RealWorld (IOUArray i Int8) -&gt; IO (IOUArray i Int8)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-228"></span><span>        </span><span id="local-6989586621679053470"><span class="annot"><span class="annottext">STUArray RealWorld i Int8
</span><a href="#local-6989586621679053470"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Int8 -&gt; ST RealWorld (STUArray RealWorld i Int8)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053472"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Int8
</span><a href="#local-6989586621679053471"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Int8 -&gt; ST RealWorld (IOUArray i Int8)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int8 -&gt; IOUArray i Int8
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int8
</span><a href="#local-6989586621679053470"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-229"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-230"></span><span>    </span><span id="local-6989586621679053464"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Int8)
</span><a href="#local-6989586621679053464"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053463"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053463"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Int8) -&gt; IO (IOUArray i Int8)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Int8) -&gt; IO (IOUArray i Int8))
-&gt; ST RealWorld (IOUArray i Int8) -&gt; IO (IOUArray i Int8)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-231"></span><span>        </span><span id="local-6989586621679053462"><span class="annot"><span class="annottext">STUArray RealWorld i Int8
</span><a href="#local-6989586621679053462"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Int8)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053463"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Int8 -&gt; ST RealWorld (IOUArray i Int8)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int8 -&gt; IOUArray i Int8
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int8
</span><a href="#local-6989586621679053462"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-232"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-233"></span><span>    </span><span id="local-6989586621679053458"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Int8)
</span><a href="#local-6989586621679053458"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Int8)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-234"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-235"></span><span>    </span><span id="local-6989586621679053454"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Int8 -&gt; Int -&gt; IO Int8
</span><a href="#local-6989586621679053454"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053453"><span class="annot"><span class="annottext">STUArray RealWorld i Int8
</span><a href="#local-6989586621679053453"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053452"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053452"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int8 -&gt; IO Int8
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int8 -&gt; Int -&gt; ST RealWorld Int8
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int8
</span><a href="#local-6989586621679053453"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053452"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-236"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-237"></span><span>    </span><span id="local-6989586621679053448"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Int8 -&gt; Int -&gt; Int8 -&gt; IO ()
</span><a href="#local-6989586621679053448"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053447"><span class="annot"><span class="annottext">STUArray RealWorld i Int8
</span><a href="#local-6989586621679053447"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053446"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053446"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053445"><span class="annot"><span class="annottext">Int8
</span><a href="#local-6989586621679053445"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int8 -&gt; Int -&gt; Int8 -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int8
</span><a href="#local-6989586621679053447"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053446"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Int8
</span><a href="#local-6989586621679053445"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-238"></span><span>
</span><span id="line-239"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int16"><span class="hs-identifier hs-type">Int16</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-240"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-241"></span><span>    </span><span id="local-6989586621679053430"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Int16 -&gt; IO (i, i)
</span><a href="#local-6989586621679053430"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053429"><span class="annot"><span class="annottext">STUArray RealWorld i Int16
</span><a href="#local-6989586621679053429"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int16 -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int16
</span><a href="#local-6989586621679053429"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-242"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-243"></span><span>    </span><span id="local-6989586621679053425"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Int16 -&gt; IO Int
</span><a href="#local-6989586621679053425"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053424"><span class="annot"><span class="annottext">STUArray RealWorld i Int16
</span><a href="#local-6989586621679053424"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int16 -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int16
</span><a href="#local-6989586621679053424"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-244"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-245"></span><span>    </span><span id="local-6989586621679053418"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Int16 -&gt; IO (IOUArray i Int16)
</span><a href="#local-6989586621679053418"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053417"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053417"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053416"><span class="annot"><span class="annottext">Int16
</span><a href="#local-6989586621679053416"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Int16) -&gt; IO (IOUArray i Int16)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Int16) -&gt; IO (IOUArray i Int16))
-&gt; ST RealWorld (IOUArray i Int16) -&gt; IO (IOUArray i Int16)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-246"></span><span>        </span><span id="local-6989586621679053415"><span class="annot"><span class="annottext">STUArray RealWorld i Int16
</span><a href="#local-6989586621679053415"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Int16 -&gt; ST RealWorld (STUArray RealWorld i Int16)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053417"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Int16
</span><a href="#local-6989586621679053416"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Int16 -&gt; ST RealWorld (IOUArray i Int16)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int16 -&gt; IOUArray i Int16
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int16
</span><a href="#local-6989586621679053415"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-247"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-248"></span><span>    </span><span id="local-6989586621679053409"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Int16)
</span><a href="#local-6989586621679053409"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053408"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053408"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Int16) -&gt; IO (IOUArray i Int16)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Int16) -&gt; IO (IOUArray i Int16))
-&gt; ST RealWorld (IOUArray i Int16) -&gt; IO (IOUArray i Int16)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-249"></span><span>        </span><span id="local-6989586621679053407"><span class="annot"><span class="annottext">STUArray RealWorld i Int16
</span><a href="#local-6989586621679053407"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Int16)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053408"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Int16 -&gt; ST RealWorld (IOUArray i Int16)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int16 -&gt; IOUArray i Int16
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int16
</span><a href="#local-6989586621679053407"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-250"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-251"></span><span>    </span><span id="local-6989586621679053403"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Int16)
</span><a href="#local-6989586621679053403"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Int16)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-252"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-253"></span><span>    </span><span id="local-6989586621679053399"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Int16 -&gt; Int -&gt; IO Int16
</span><a href="#local-6989586621679053399"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053398"><span class="annot"><span class="annottext">STUArray RealWorld i Int16
</span><a href="#local-6989586621679053398"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053397"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053397"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int16 -&gt; IO Int16
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int16 -&gt; Int -&gt; ST RealWorld Int16
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int16
</span><a href="#local-6989586621679053398"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053397"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-254"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-255"></span><span>    </span><span id="local-6989586621679053393"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Int16 -&gt; Int -&gt; Int16 -&gt; IO ()
</span><a href="#local-6989586621679053393"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053392"><span class="annot"><span class="annottext">STUArray RealWorld i Int16
</span><a href="#local-6989586621679053392"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053391"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053391"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053390"><span class="annot"><span class="annottext">Int16
</span><a href="#local-6989586621679053390"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int16 -&gt; Int -&gt; Int16 -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int16
</span><a href="#local-6989586621679053392"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053391"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Int16
</span><a href="#local-6989586621679053390"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-256"></span><span>
</span><span id="line-257"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int32"><span class="hs-identifier hs-type">Int32</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-258"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-259"></span><span>    </span><span id="local-6989586621679053375"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Int32 -&gt; IO (i, i)
</span><a href="#local-6989586621679053375"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053374"><span class="annot"><span class="annottext">STUArray RealWorld i Int32
</span><a href="#local-6989586621679053374"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int32 -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int32
</span><a href="#local-6989586621679053374"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-260"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-261"></span><span>    </span><span id="local-6989586621679053370"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Int32 -&gt; IO Int
</span><a href="#local-6989586621679053370"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053369"><span class="annot"><span class="annottext">STUArray RealWorld i Int32
</span><a href="#local-6989586621679053369"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int32 -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int32
</span><a href="#local-6989586621679053369"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-262"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-263"></span><span>    </span><span id="local-6989586621679053363"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Int32 -&gt; IO (IOUArray i Int32)
</span><a href="#local-6989586621679053363"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053362"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053362"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053361"><span class="annot"><span class="annottext">Int32
</span><a href="#local-6989586621679053361"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Int32) -&gt; IO (IOUArray i Int32)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Int32) -&gt; IO (IOUArray i Int32))
-&gt; ST RealWorld (IOUArray i Int32) -&gt; IO (IOUArray i Int32)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-264"></span><span>        </span><span id="local-6989586621679053360"><span class="annot"><span class="annottext">STUArray RealWorld i Int32
</span><a href="#local-6989586621679053360"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Int32 -&gt; ST RealWorld (STUArray RealWorld i Int32)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053362"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Int32
</span><a href="#local-6989586621679053361"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Int32 -&gt; ST RealWorld (IOUArray i Int32)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int32 -&gt; IOUArray i Int32
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int32
</span><a href="#local-6989586621679053360"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-265"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-266"></span><span>    </span><span id="local-6989586621679053354"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Int32)
</span><a href="#local-6989586621679053354"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053353"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053353"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Int32) -&gt; IO (IOUArray i Int32)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Int32) -&gt; IO (IOUArray i Int32))
-&gt; ST RealWorld (IOUArray i Int32) -&gt; IO (IOUArray i Int32)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-267"></span><span>        </span><span id="local-6989586621679053352"><span class="annot"><span class="annottext">STUArray RealWorld i Int32
</span><a href="#local-6989586621679053352"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Int32)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053353"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Int32 -&gt; ST RealWorld (IOUArray i Int32)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int32 -&gt; IOUArray i Int32
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int32
</span><a href="#local-6989586621679053352"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-268"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-269"></span><span>    </span><span id="local-6989586621679053348"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Int32)
</span><a href="#local-6989586621679053348"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Int32)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-270"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-271"></span><span>    </span><span id="local-6989586621679053344"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Int32 -&gt; Int -&gt; IO Int32
</span><a href="#local-6989586621679053344"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053343"><span class="annot"><span class="annottext">STUArray RealWorld i Int32
</span><a href="#local-6989586621679053343"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053342"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053342"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int32 -&gt; IO Int32
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int32 -&gt; Int -&gt; ST RealWorld Int32
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int32
</span><a href="#local-6989586621679053343"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053342"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-272"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-273"></span><span>    </span><span id="local-6989586621679053338"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Int32 -&gt; Int -&gt; Int32 -&gt; IO ()
</span><a href="#local-6989586621679053338"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053337"><span class="annot"><span class="annottext">STUArray RealWorld i Int32
</span><a href="#local-6989586621679053337"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053336"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053336"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053335"><span class="annot"><span class="annottext">Int32
</span><a href="#local-6989586621679053335"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int32 -&gt; Int -&gt; Int32 -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int32
</span><a href="#local-6989586621679053337"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053336"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Int32
</span><a href="#local-6989586621679053335"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-274"></span><span>
</span><span id="line-275"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Int.html#Int64"><span class="hs-identifier hs-type">Int64</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-276"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-277"></span><span>    </span><span id="local-6989586621679053320"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Int64 -&gt; IO (i, i)
</span><a href="#local-6989586621679053320"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053319"><span class="annot"><span class="annottext">STUArray RealWorld i Int64
</span><a href="#local-6989586621679053319"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int64 -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int64
</span><a href="#local-6989586621679053319"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-278"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-279"></span><span>    </span><span id="local-6989586621679053315"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Int64 -&gt; IO Int
</span><a href="#local-6989586621679053315"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053314"><span class="annot"><span class="annottext">STUArray RealWorld i Int64
</span><a href="#local-6989586621679053314"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int64 -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int64
</span><a href="#local-6989586621679053314"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-280"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-281"></span><span>    </span><span id="local-6989586621679053308"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Int64 -&gt; IO (IOUArray i Int64)
</span><a href="#local-6989586621679053308"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053307"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053307"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053306"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679053306"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Int64) -&gt; IO (IOUArray i Int64)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Int64) -&gt; IO (IOUArray i Int64))
-&gt; ST RealWorld (IOUArray i Int64) -&gt; IO (IOUArray i Int64)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-282"></span><span>        </span><span id="local-6989586621679053305"><span class="annot"><span class="annottext">STUArray RealWorld i Int64
</span><a href="#local-6989586621679053305"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Int64 -&gt; ST RealWorld (STUArray RealWorld i Int64)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053307"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679053306"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Int64 -&gt; ST RealWorld (IOUArray i Int64)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int64 -&gt; IOUArray i Int64
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int64
</span><a href="#local-6989586621679053305"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-283"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-284"></span><span>    </span><span id="local-6989586621679053299"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Int64)
</span><a href="#local-6989586621679053299"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053298"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053298"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Int64) -&gt; IO (IOUArray i Int64)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Int64) -&gt; IO (IOUArray i Int64))
-&gt; ST RealWorld (IOUArray i Int64) -&gt; IO (IOUArray i Int64)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-285"></span><span>        </span><span id="local-6989586621679053297"><span class="annot"><span class="annottext">STUArray RealWorld i Int64
</span><a href="#local-6989586621679053297"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Int64)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053298"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Int64 -&gt; ST RealWorld (IOUArray i Int64)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int64 -&gt; IOUArray i Int64
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int64
</span><a href="#local-6989586621679053297"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-286"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-287"></span><span>    </span><span id="local-6989586621679053293"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Int64)
</span><a href="#local-6989586621679053293"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Int64)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-288"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-289"></span><span>    </span><span id="local-6989586621679053289"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Int64 -&gt; Int -&gt; IO Int64
</span><a href="#local-6989586621679053289"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053288"><span class="annot"><span class="annottext">STUArray RealWorld i Int64
</span><a href="#local-6989586621679053288"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053287"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053287"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int64 -&gt; IO Int64
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int64 -&gt; Int -&gt; ST RealWorld Int64
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int64
</span><a href="#local-6989586621679053288"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053287"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-290"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-291"></span><span>    </span><span id="local-6989586621679053283"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Int64 -&gt; Int -&gt; Int64 -&gt; IO ()
</span><a href="#local-6989586621679053283"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053282"><span class="annot"><span class="annottext">STUArray RealWorld i Int64
</span><a href="#local-6989586621679053282"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053281"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053281"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053280"><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679053280"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Int64 -&gt; Int -&gt; Int64 -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Int64
</span><a href="#local-6989586621679053282"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053281"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Int64
</span><a href="#local-6989586621679053280"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-292"></span><span>
</span><span id="line-293"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-294"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-295"></span><span>    </span><span id="local-6989586621679053265"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Word8 -&gt; IO (i, i)
</span><a href="#local-6989586621679053265"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053264"><span class="annot"><span class="annottext">STUArray RealWorld i Word8
</span><a href="#local-6989586621679053264"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word8 -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word8
</span><a href="#local-6989586621679053264"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-296"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-297"></span><span>    </span><span id="local-6989586621679053260"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Word8 -&gt; IO Int
</span><a href="#local-6989586621679053260"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053259"><span class="annot"><span class="annottext">STUArray RealWorld i Word8
</span><a href="#local-6989586621679053259"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word8 -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word8
</span><a href="#local-6989586621679053259"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-298"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-299"></span><span>    </span><span id="local-6989586621679053253"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Word8 -&gt; IO (IOUArray i Word8)
</span><a href="#local-6989586621679053253"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053252"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053252"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053251"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679053251"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Word8) -&gt; IO (IOUArray i Word8)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Word8) -&gt; IO (IOUArray i Word8))
-&gt; ST RealWorld (IOUArray i Word8) -&gt; IO (IOUArray i Word8)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-300"></span><span>        </span><span id="local-6989586621679053250"><span class="annot"><span class="annottext">STUArray RealWorld i Word8
</span><a href="#local-6989586621679053250"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Word8 -&gt; ST RealWorld (STUArray RealWorld i Word8)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053252"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679053251"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Word8 -&gt; ST RealWorld (IOUArray i Word8)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word8 -&gt; IOUArray i Word8
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word8
</span><a href="#local-6989586621679053250"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-301"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-302"></span><span>    </span><span id="local-6989586621679053244"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Word8)
</span><a href="#local-6989586621679053244"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053243"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053243"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Word8) -&gt; IO (IOUArray i Word8)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Word8) -&gt; IO (IOUArray i Word8))
-&gt; ST RealWorld (IOUArray i Word8) -&gt; IO (IOUArray i Word8)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-303"></span><span>        </span><span id="local-6989586621679053242"><span class="annot"><span class="annottext">STUArray RealWorld i Word8
</span><a href="#local-6989586621679053242"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Word8)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053243"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Word8 -&gt; ST RealWorld (IOUArray i Word8)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word8 -&gt; IOUArray i Word8
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word8
</span><a href="#local-6989586621679053242"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-304"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-305"></span><span>    </span><span id="local-6989586621679053238"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Word8)
</span><a href="#local-6989586621679053238"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Word8)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-306"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-307"></span><span>    </span><span id="local-6989586621679053234"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Word8 -&gt; Int -&gt; IO Word8
</span><a href="#local-6989586621679053234"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053233"><span class="annot"><span class="annottext">STUArray RealWorld i Word8
</span><a href="#local-6989586621679053233"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053232"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053232"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Word8 -&gt; IO Word8
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word8 -&gt; Int -&gt; ST RealWorld Word8
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word8
</span><a href="#local-6989586621679053233"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053232"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-308"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-309"></span><span>    </span><span id="local-6989586621679053228"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Word8 -&gt; Int -&gt; Word8 -&gt; IO ()
</span><a href="#local-6989586621679053228"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053227"><span class="annot"><span class="annottext">STUArray RealWorld i Word8
</span><a href="#local-6989586621679053227"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053226"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053226"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053225"><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679053225"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word8 -&gt; Int -&gt; Word8 -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word8
</span><a href="#local-6989586621679053227"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053226"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Word8
</span><a href="#local-6989586621679053225"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-310"></span><span>
</span><span id="line-311"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-312"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-313"></span><span>    </span><span id="local-6989586621679053210"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Word16 -&gt; IO (i, i)
</span><a href="#local-6989586621679053210"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053209"><span class="annot"><span class="annottext">STUArray RealWorld i Word16
</span><a href="#local-6989586621679053209"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word16 -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word16
</span><a href="#local-6989586621679053209"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-314"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-315"></span><span>    </span><span id="local-6989586621679053205"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Word16 -&gt; IO Int
</span><a href="#local-6989586621679053205"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053204"><span class="annot"><span class="annottext">STUArray RealWorld i Word16
</span><a href="#local-6989586621679053204"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word16 -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word16
</span><a href="#local-6989586621679053204"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-316"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-317"></span><span>    </span><span id="local-6989586621679053198"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Word16 -&gt; IO (IOUArray i Word16)
</span><a href="#local-6989586621679053198"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053197"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053197"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053196"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621679053196"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Word16) -&gt; IO (IOUArray i Word16)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Word16) -&gt; IO (IOUArray i Word16))
-&gt; ST RealWorld (IOUArray i Word16) -&gt; IO (IOUArray i Word16)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-318"></span><span>        </span><span id="local-6989586621679053195"><span class="annot"><span class="annottext">STUArray RealWorld i Word16
</span><a href="#local-6989586621679053195"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Word16 -&gt; ST RealWorld (STUArray RealWorld i Word16)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053197"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621679053196"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Word16 -&gt; ST RealWorld (IOUArray i Word16)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word16 -&gt; IOUArray i Word16
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word16
</span><a href="#local-6989586621679053195"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-319"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-320"></span><span>    </span><span id="local-6989586621679053189"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Word16)
</span><a href="#local-6989586621679053189"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053188"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053188"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Word16) -&gt; IO (IOUArray i Word16)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Word16) -&gt; IO (IOUArray i Word16))
-&gt; ST RealWorld (IOUArray i Word16) -&gt; IO (IOUArray i Word16)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-321"></span><span>        </span><span id="local-6989586621679053187"><span class="annot"><span class="annottext">STUArray RealWorld i Word16
</span><a href="#local-6989586621679053187"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Word16)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053188"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Word16 -&gt; ST RealWorld (IOUArray i Word16)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word16 -&gt; IOUArray i Word16
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word16
</span><a href="#local-6989586621679053187"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-322"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-323"></span><span>    </span><span id="local-6989586621679053183"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Word16)
</span><a href="#local-6989586621679053183"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Word16)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-324"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-325"></span><span>    </span><span id="local-6989586621679053179"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Word16 -&gt; Int -&gt; IO Word16
</span><a href="#local-6989586621679053179"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053178"><span class="annot"><span class="annottext">STUArray RealWorld i Word16
</span><a href="#local-6989586621679053178"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053177"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053177"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Word16 -&gt; IO Word16
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word16 -&gt; Int -&gt; ST RealWorld Word16
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word16
</span><a href="#local-6989586621679053178"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053177"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-326"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-327"></span><span>    </span><span id="local-6989586621679053173"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Word16 -&gt; Int -&gt; Word16 -&gt; IO ()
</span><a href="#local-6989586621679053173"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053172"><span class="annot"><span class="annottext">STUArray RealWorld i Word16
</span><a href="#local-6989586621679053172"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053171"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053171"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053170"><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621679053170"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word16 -&gt; Int -&gt; Word16 -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word16
</span><a href="#local-6989586621679053172"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053171"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Word16
</span><a href="#local-6989586621679053170"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-328"></span><span>
</span><span id="line-329"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-330"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-331"></span><span>    </span><span id="local-6989586621679053155"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Word32 -&gt; IO (i, i)
</span><a href="#local-6989586621679053155"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053154"><span class="annot"><span class="annottext">STUArray RealWorld i Word32
</span><a href="#local-6989586621679053154"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word32 -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word32
</span><a href="#local-6989586621679053154"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-332"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-333"></span><span>    </span><span id="local-6989586621679053150"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Word32 -&gt; IO Int
</span><a href="#local-6989586621679053150"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053149"><span class="annot"><span class="annottext">STUArray RealWorld i Word32
</span><a href="#local-6989586621679053149"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word32 -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word32
</span><a href="#local-6989586621679053149"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-334"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-335"></span><span>    </span><span id="local-6989586621679053143"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Word32 -&gt; IO (IOUArray i Word32)
</span><a href="#local-6989586621679053143"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053142"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053142"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053141"><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621679053141"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Word32) -&gt; IO (IOUArray i Word32)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Word32) -&gt; IO (IOUArray i Word32))
-&gt; ST RealWorld (IOUArray i Word32) -&gt; IO (IOUArray i Word32)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-336"></span><span>        </span><span id="local-6989586621679053140"><span class="annot"><span class="annottext">STUArray RealWorld i Word32
</span><a href="#local-6989586621679053140"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Word32 -&gt; ST RealWorld (STUArray RealWorld i Word32)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053142"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621679053141"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Word32 -&gt; ST RealWorld (IOUArray i Word32)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word32 -&gt; IOUArray i Word32
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word32
</span><a href="#local-6989586621679053140"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-337"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-338"></span><span>    </span><span id="local-6989586621679053134"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Word32)
</span><a href="#local-6989586621679053134"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053133"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053133"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Word32) -&gt; IO (IOUArray i Word32)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Word32) -&gt; IO (IOUArray i Word32))
-&gt; ST RealWorld (IOUArray i Word32) -&gt; IO (IOUArray i Word32)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-339"></span><span>        </span><span id="local-6989586621679053132"><span class="annot"><span class="annottext">STUArray RealWorld i Word32
</span><a href="#local-6989586621679053132"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Word32)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053133"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Word32 -&gt; ST RealWorld (IOUArray i Word32)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word32 -&gt; IOUArray i Word32
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word32
</span><a href="#local-6989586621679053132"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-340"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-341"></span><span>    </span><span id="local-6989586621679053128"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Word32)
</span><a href="#local-6989586621679053128"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Word32)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-342"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-343"></span><span>    </span><span id="local-6989586621679053124"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Word32 -&gt; Int -&gt; IO Word32
</span><a href="#local-6989586621679053124"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053123"><span class="annot"><span class="annottext">STUArray RealWorld i Word32
</span><a href="#local-6989586621679053123"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053122"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053122"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Word32 -&gt; IO Word32
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word32 -&gt; Int -&gt; ST RealWorld Word32
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word32
</span><a href="#local-6989586621679053123"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053122"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-344"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-345"></span><span>    </span><span id="local-6989586621679053118"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Word32 -&gt; Int -&gt; Word32 -&gt; IO ()
</span><a href="#local-6989586621679053118"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053117"><span class="annot"><span class="annottext">STUArray RealWorld i Word32
</span><a href="#local-6989586621679053117"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053116"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053116"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053115"><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621679053115"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word32 -&gt; Int -&gt; Word32 -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word32
</span><a href="#local-6989586621679053117"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053116"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Word32
</span><a href="#local-6989586621679053115"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-346"></span><span>
</span><span id="line-347"></span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="Data.Array.Base.html#MArray"><span class="hs-identifier hs-type">MArray</span></a></span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="../../base/src/GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-348"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getBounds"><span class="hs-pragma hs-type">getBounds</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-349"></span><span>    </span><span id="local-6989586621679053100"><span class="annot"><span class="annottext">getBounds :: forall i. Ix i =&gt; IOUArray i Word64 -&gt; IO (i, i)
</span><a href="#local-6989586621679053100"><span class="hs-identifier hs-var hs-var hs-var hs-var">getBounds</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053099"><span class="annot"><span class="annottext">STUArray RealWorld i Word64
</span><a href="#local-6989586621679053099"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (i, i) -&gt; IO (i, i)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (i, i) -&gt; IO (i, i))
-&gt; ST RealWorld (i, i) -&gt; IO (i, i)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word64 -&gt; ST RealWorld (i, i)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m (i, i)
</span><a href="Data.Array.Base.html#getBounds"><span class="hs-identifier hs-var">getBounds</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word64
</span><a href="#local-6989586621679053099"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-350"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#getNumElements"><span class="hs-pragma hs-type">getNumElements</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-351"></span><span>    </span><span id="local-6989586621679053095"><span class="annot"><span class="annottext">getNumElements :: forall i. Ix i =&gt; IOUArray i Word64 -&gt; IO Int
</span><a href="#local-6989586621679053095"><span class="hs-identifier hs-var hs-var hs-var hs-var">getNumElements</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053094"><span class="annot"><span class="annottext">STUArray RealWorld i Word64
</span><a href="#local-6989586621679053094"><span class="hs-identifier hs-var">arr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Int -&gt; IO Int
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld Int -&gt; IO Int) -&gt; ST RealWorld Int -&gt; IO Int
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word64 -&gt; ST RealWorld Int
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; m Int
</span><a href="Data.Array.Base.html#getNumElements"><span class="hs-identifier hs-var">getNumElements</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word64
</span><a href="#local-6989586621679053094"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-352"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray"><span class="hs-pragma hs-type">newArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-353"></span><span>    </span><span id="local-6989586621679053088"><span class="annot"><span class="annottext">newArray :: forall i. Ix i =&gt; (i, i) -&gt; Word64 -&gt; IO (IOUArray i Word64)
</span><a href="#local-6989586621679053088"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray</span></a></span></span><span> </span><span id="local-6989586621679053087"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053087"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span id="local-6989586621679053086"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679053086"><span class="hs-identifier hs-var">initialValue</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Word64) -&gt; IO (IOUArray i Word64)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Word64) -&gt; IO (IOUArray i Word64))
-&gt; ST RealWorld (IOUArray i Word64) -&gt; IO (IOUArray i Word64)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-354"></span><span>        </span><span id="local-6989586621679053085"><span class="annot"><span class="annottext">STUArray RealWorld i Word64
</span><a href="#local-6989586621679053085"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; Word64 -&gt; ST RealWorld (STUArray RealWorld i Word64)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; e -&gt; m (a i e)
</span><a href="Data.Array.Base.html#newArray"><span class="hs-identifier hs-var">newArray</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053087"><span class="hs-identifier hs-var">lu</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679053086"><span class="hs-identifier hs-var">initialValue</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Word64 -&gt; ST RealWorld (IOUArray i Word64)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word64 -&gt; IOUArray i Word64
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word64
</span><a href="#local-6989586621679053085"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-355"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-pragma hs-type">unsafeNewArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-356"></span><span>    </span><span id="local-6989586621679053079"><span class="annot"><span class="annottext">unsafeNewArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Word64)
</span><a href="#local-6989586621679053079"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeNewArray_</span></a></span></span><span> </span><span id="local-6989586621679053078"><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053078"><span class="hs-identifier hs-var">lu</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray i Word64) -&gt; IO (IOUArray i Word64)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray i Word64) -&gt; IO (IOUArray i Word64))
-&gt; ST RealWorld (IOUArray i Word64) -&gt; IO (IOUArray i Word64)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-357"></span><span>        </span><span id="local-6989586621679053077"><span class="annot"><span class="annottext">STUArray RealWorld i Word64
</span><a href="#local-6989586621679053077"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; ST RealWorld (STUArray RealWorld i Word64)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span> </span><span class="annot"><span class="annottext">(i, i)
</span><a href="#local-6989586621679053078"><span class="hs-identifier hs-var">lu</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">IOUArray i Word64 -&gt; ST RealWorld (IOUArray i Word64)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word64 -&gt; IOUArray i Word64
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word64
</span><a href="#local-6989586621679053077"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-358"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#newArray_"><span class="hs-pragma hs-type">newArray_</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-359"></span><span>    </span><span id="local-6989586621679053073"><span class="annot"><span class="annottext">newArray_ :: forall i. Ix i =&gt; (i, i) -&gt; IO (IOUArray i Word64)
</span><a href="#local-6989586621679053073"><span class="hs-identifier hs-var hs-var hs-var hs-var">newArray_</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(i, i) -&gt; IO (IOUArray i Word64)
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
(i, i) -&gt; m (a i e)
</span><a href="Data.Array.Base.html#unsafeNewArray_"><span class="hs-identifier hs-var">unsafeNewArray_</span></a></span><span>
</span><span id="line-360"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeRead"><span class="hs-pragma hs-type">unsafeRead</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-361"></span><span>    </span><span id="local-6989586621679053069"><span class="annot"><span class="annottext">unsafeRead :: forall i. Ix i =&gt; IOUArray i Word64 -&gt; Int -&gt; IO Word64
</span><a href="#local-6989586621679053069"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeRead</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053068"><span class="annot"><span class="annottext">STUArray RealWorld i Word64
</span><a href="#local-6989586621679053068"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053067"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053067"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld Word64 -&gt; IO Word64
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word64 -&gt; Int -&gt; ST RealWorld Word64
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; m e
</span><a href="Data.Array.Base.html#unsafeRead"><span class="hs-identifier hs-var">unsafeRead</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word64
</span><a href="#local-6989586621679053068"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053067"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-362"></span><span>    </span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-pragma hs-type">unsafeWrite</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-363"></span><span>    </span><span id="local-6989586621679053063"><span class="annot"><span class="annottext">unsafeWrite :: forall i. Ix i =&gt; IOUArray i Word64 -&gt; Int -&gt; Word64 -&gt; IO ()
</span><a href="#local-6989586621679053063"><span class="hs-identifier hs-var hs-var hs-var hs-var">unsafeWrite</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053062"><span class="annot"><span class="annottext">STUArray RealWorld i Word64
</span><a href="#local-6989586621679053062"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span id="local-6989586621679053061"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053061"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span id="local-6989586621679053060"><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679053060"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld () -&gt; IO ()
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld i Word64 -&gt; Int -&gt; Word64 -&gt; ST RealWorld ()
forall (a :: * -&gt; * -&gt; *) e (m :: * -&gt; *) i.
(MArray a e m, Ix i) =&gt;
a i e -&gt; Int -&gt; e -&gt; m ()
</span><a href="Data.Array.Base.html#unsafeWrite"><span class="hs-identifier hs-var">unsafeWrite</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld i Word64
</span><a href="#local-6989586621679053062"><span class="hs-identifier hs-var">marr</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679053061"><span class="hs-identifier hs-var">i</span></a></span><span> </span><span class="annot"><span class="annottext">Word64
</span><a href="#local-6989586621679053060"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-364"></span><span>
</span><span id="line-365"></span><span class="hs-comment">-- | Casts an 'IOUArray' with one element type into one with a</span><span>
</span><span id="line-366"></span><span class="hs-comment">-- different element type.  All the elements of the resulting array</span><span>
</span><span id="line-367"></span><span class="hs-comment">-- are undefined (unless you know what you\'re doing...).</span><span>
</span><span id="line-368"></span><span id="local-6989586621679054048"><span id="local-6989586621679054049"><span id="local-6989586621679054050"><span class="annot"><a href="Data.Array.IO.Internals.html#castIOUArray"><span class="hs-identifier hs-type">castIOUArray</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054050"><span class="hs-identifier hs-type">ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054049"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054050"><span class="hs-identifier hs-type">ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054048"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span></span></span><span>
</span><span id="line-369"></span><span id="castIOUArray"><span class="annot"><span class="annottext">castIOUArray :: forall ix a b. IOUArray ix a -&gt; IO (IOUArray ix b)
</span><a href="Data.Array.IO.Internals.html#castIOUArray"><span class="hs-identifier hs-var hs-var">castIOUArray</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053057"><span class="annot"><span class="annottext">STUArray RealWorld ix a
</span><a href="#local-6989586621679053057"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray ix b) -&gt; IO (IOUArray ix b)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray ix b) -&gt; IO (IOUArray ix b))
-&gt; ST RealWorld (IOUArray ix b) -&gt; IO (IOUArray ix b)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-370"></span><span>    </span><span id="local-6989586621679053056"><span class="annot"><span class="annottext">STUArray RealWorld ix b
</span><a href="#local-6989586621679053056"><span class="hs-identifier hs-var">marr'</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld ix a -&gt; ST RealWorld (STUArray RealWorld ix b)
forall s ix a b. STUArray s ix a -&gt; ST s (STUArray s ix b)
</span><a href="Data.Array.Base.html#castSTUArray"><span class="hs-identifier hs-var">castSTUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld ix a
</span><a href="#local-6989586621679053057"><span class="hs-identifier hs-var">marr</span></a></span><span>
</span><span id="line-371"></span><span>    </span><span class="annot"><span class="annottext">IOUArray ix b -&gt; ST RealWorld (IOUArray ix b)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld ix b -&gt; IOUArray ix b
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld ix b
</span><a href="#local-6989586621679053056"><span class="hs-identifier hs-var">marr'</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-372"></span><span>
</span><span id="line-373"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#unsafeThawIOUArray"><span class="hs-pragma hs-type">unsafeThawIOUArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-374"></span><span id="local-6989586621679054039"><span id="local-6989586621679054040"><span class="annot"><a href="Data.Array.IO.Internals.html#unsafeThawIOUArray"><span class="hs-identifier hs-type">unsafeThawIOUArray</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Array.Base.html#UArray"><span class="hs-identifier hs-type">UArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054040"><span class="hs-identifier hs-type">ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054039"><span class="hs-identifier hs-type">e</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054040"><span class="hs-identifier hs-type">ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054039"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-375"></span><span id="unsafeThawIOUArray"><span class="annot"><span class="annottext">unsafeThawIOUArray :: forall ix e. UArray ix e -&gt; IO (IOUArray ix e)
</span><a href="Data.Array.IO.Internals.html#unsafeThawIOUArray"><span class="hs-identifier hs-var hs-var">unsafeThawIOUArray</span></a></span></span><span> </span><span id="local-6989586621679053052"><span class="annot"><span class="annottext">UArray ix e
</span><a href="#local-6989586621679053052"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray ix e) -&gt; IO (IOUArray ix e)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray ix e) -&gt; IO (IOUArray ix e))
-&gt; ST RealWorld (IOUArray ix e) -&gt; IO (IOUArray ix e)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-376"></span><span>    </span><span id="local-6989586621679053051"><span class="annot"><span class="annottext">STUArray RealWorld ix e
</span><a href="#local-6989586621679053051"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">UArray ix e -&gt; ST RealWorld (STUArray RealWorld ix e)
forall i e s. UArray i e -&gt; ST s (STUArray s i e)
</span><a href="Data.Array.Base.html#unsafeThawSTUArray"><span class="hs-identifier hs-var">unsafeThawSTUArray</span></a></span><span> </span><span class="annot"><span class="annottext">UArray ix e
</span><a href="#local-6989586621679053052"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-377"></span><span>    </span><span class="annot"><span class="annottext">IOUArray ix e -&gt; ST RealWorld (IOUArray ix e)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld ix e -&gt; IOUArray ix e
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld ix e
</span><a href="#local-6989586621679053051"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-378"></span><span>
</span><span id="line-379"></span><span class="hs-pragma">{-# RULES</span><span>
</span><span id="line-380"></span><span class="annot"><span class="hs-pragma">&quot;unsafeThaw/IOUArray&quot;</span></span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeThaw"><span class="hs-pragma hs-type">unsafeThaw</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#unsafeThawIOUArray"><span class="hs-pragma hs-type">unsafeThawIOUArray</span></a></span><span>
</span><span id="line-381"></span><span>    </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-382"></span><span>
</span><span id="line-383"></span><span id="local-6989586621679053047"><span id="local-6989586621679053048"><span class="annot"><a href="Data.Array.IO.Internals.html#thawIOUArray"><span class="hs-identifier hs-type">thawIOUArray</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Array.Base.html#UArray"><span class="hs-identifier hs-type">UArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679053048"><span class="hs-identifier hs-type">ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679053047"><span class="hs-identifier hs-type">e</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679053048"><span class="hs-identifier hs-type">ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679053047"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-384"></span><span id="thawIOUArray"><span class="annot"><span class="annottext">thawIOUArray :: forall ix e. UArray ix e -&gt; IO (IOUArray ix e)
</span><a href="Data.Array.IO.Internals.html#thawIOUArray"><span class="hs-identifier hs-var hs-var">thawIOUArray</span></a></span></span><span> </span><span id="local-6989586621679053043"><span class="annot"><span class="annottext">UArray ix e
</span><a href="#local-6989586621679053043"><span class="hs-identifier hs-var">arr</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (IOUArray ix e) -&gt; IO (IOUArray ix e)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="annot"><span class="annottext">(ST RealWorld (IOUArray ix e) -&gt; IO (IOUArray ix e))
-&gt; ST RealWorld (IOUArray ix e) -&gt; IO (IOUArray ix e)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="../../base/src/GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-385"></span><span>    </span><span id="local-6989586621679053042"><span class="annot"><span class="annottext">STUArray RealWorld ix e
</span><a href="#local-6989586621679053042"><span class="hs-identifier hs-var">marr</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">UArray ix e -&gt; ST RealWorld (STUArray RealWorld ix e)
forall i e s. UArray i e -&gt; ST s (STUArray s i e)
</span><a href="Data.Array.Base.html#thawSTUArray"><span class="hs-identifier hs-var">thawSTUArray</span></a></span><span> </span><span class="annot"><span class="annottext">UArray ix e
</span><a href="#local-6989586621679053043"><span class="hs-identifier hs-var">arr</span></a></span><span>
</span><span id="line-386"></span><span>    </span><span class="annot"><span class="annottext">IOUArray ix e -&gt; ST RealWorld (IOUArray ix e)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="../../base/src/GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld ix e -&gt; IOUArray ix e
forall i e. STUArray RealWorld i e -&gt; IOUArray i e
</span><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-var">IOUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld ix e
</span><a href="#local-6989586621679053042"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-387"></span><span>
</span><span id="line-388"></span><span class="hs-pragma">{-# RULES</span><span>
</span><span id="line-389"></span><span class="annot"><span class="hs-pragma">&quot;thaw/IOUArray&quot;</span></span><span> </span><span class="annot"><a href="Data.Array.Base.html#thaw"><span class="hs-pragma hs-type">thaw</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#thawIOUArray"><span class="hs-pragma hs-type">thawIOUArray</span></a></span><span>
</span><span id="line-390"></span><span>    </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-391"></span><span>
</span><span id="line-392"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#unsafeFreezeIOUArray"><span class="hs-pragma hs-type">unsafeFreezeIOUArray</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-393"></span><span id="local-6989586621679054029"><span id="local-6989586621679054030"><span class="annot"><a href="Data.Array.IO.Internals.html#unsafeFreezeIOUArray"><span class="hs-identifier hs-type">unsafeFreezeIOUArray</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054030"><span class="hs-identifier hs-type">ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054029"><span class="hs-identifier hs-type">e</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.Base.html#UArray"><span class="hs-identifier hs-type">UArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054030"><span class="hs-identifier hs-type">ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679054029"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-394"></span><span id="unsafeFreezeIOUArray"><span class="annot"><span class="annottext">unsafeFreezeIOUArray :: forall ix e. IOUArray ix e -&gt; IO (UArray ix e)
</span><a href="Data.Array.IO.Internals.html#unsafeFreezeIOUArray"><span class="hs-identifier hs-var hs-var">unsafeFreezeIOUArray</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053039"><span class="annot"><span class="annottext">STUArray RealWorld ix e
</span><a href="#local-6989586621679053039"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (UArray ix e) -&gt; IO (UArray ix e)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld ix e -&gt; ST RealWorld (UArray ix e)
forall s i e. STUArray s i e -&gt; ST s (UArray i e)
</span><a href="Data.Array.Base.html#unsafeFreezeSTUArray"><span class="hs-identifier hs-var">unsafeFreezeSTUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld ix e
</span><a href="#local-6989586621679053039"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-395"></span><span>
</span><span id="line-396"></span><span class="hs-pragma">{-# RULES</span><span>
</span><span id="line-397"></span><span class="annot"><span class="hs-pragma">&quot;unsafeFreeze/IOUArray&quot;</span></span><span> </span><span class="annot"><a href="Data.Array.Base.html#unsafeFreeze"><span class="hs-pragma hs-type">unsafeFreeze</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#unsafeFreezeIOUArray"><span class="hs-pragma hs-type">unsafeFreezeIOUArray</span></a></span><span>
</span><span id="line-398"></span><span>    </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-399"></span><span>
</span><span id="line-400"></span><span id="local-6989586621679053035"><span id="local-6989586621679053036"><span class="annot"><a href="Data.Array.IO.Internals.html#freezeIOUArray"><span class="hs-identifier hs-type">freezeIOUArray</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679053036"><span class="hs-identifier hs-type">ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679053035"><span class="hs-identifier hs-type">e</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="hs-identifier hs-type">IO</span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.Base.html#UArray"><span class="hs-identifier hs-type">UArray</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679053036"><span class="hs-identifier hs-type">ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679053035"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-401"></span><span id="freezeIOUArray"><span class="annot"><span class="annottext">freezeIOUArray :: forall ix e. IOUArray ix e -&gt; IO (UArray ix e)
</span><a href="Data.Array.IO.Internals.html#freezeIOUArray"><span class="hs-identifier hs-var hs-var">freezeIOUArray</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Data.Array.IO.Internals.html#IOUArray"><span class="hs-identifier hs-type">IOUArray</span></a></span><span> </span><span id="local-6989586621679053033"><span class="annot"><span class="annottext">STUArray RealWorld ix e
</span><a href="#local-6989586621679053033"><span class="hs-identifier hs-var">marr</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ST RealWorld (UArray ix e) -&gt; IO (UArray ix e)
forall a. ST RealWorld a -&gt; IO a
</span><a href="../../base/src/GHC.IO.html#stToIO"><span class="hs-identifier hs-var">stToIO</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">STUArray RealWorld ix e -&gt; ST RealWorld (UArray ix e)
forall s i e. STUArray s i e -&gt; ST s (UArray i e)
</span><a href="Data.Array.Base.html#freezeSTUArray"><span class="hs-identifier hs-var">freezeSTUArray</span></a></span><span> </span><span class="annot"><span class="annottext">STUArray RealWorld ix e
</span><a href="#local-6989586621679053033"><span class="hs-identifier hs-var">marr</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-402"></span><span>
</span><span id="line-403"></span><span class="hs-pragma">{-# RULES</span><span>
</span><span id="line-404"></span><span class="annot"><span class="hs-pragma">&quot;freeze/IOUArray&quot;</span></span><span> </span><span class="annot"><a href="Data.Array.Base.html#freeze"><span class="hs-pragma hs-type">freeze</span></a></span><span> </span><span class="hs-pragma">=</span><span> </span><span class="annot"><a href="Data.Array.IO.Internals.html#freezeIOUArray"><span class="hs-pragma hs-type">freezeIOUArray</span></a></span><span>
</span><span id="line-405"></span><span>    </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-406"></span></pre></body></html>